#ifndef VECTOR_LIST_ADAPTER_H
#define VECTOR_LIST_ADAPTER_H

#include <vector>
#include <stdexcept>
#include <iterator>
#include <algorithm>
#include <initializer_list>

/**
 * VectorListAdapter: 将C++ std::vector适配为Java List风格的接口
 * 提供熟悉的Java List方法，同时保持C++的性能优势
 *
 * @template T 元素类型
 */
template<typename T>
class List {
private:
    std::vector<T> data;  // 底层vector存储

public:
    // ========== 类型定义 ==========
    using value_type = T;
    using size_type = typename std::vector<T>::size_type;
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;
    using reverse_iterator = typename std::vector<T>::reverse_iterator;
    using const_reverse_iterator = typename std::vector<T>::const_reverse_iterator;

    // ========== 构造函数和析构函数 ==========

    /**
     * 默认构造函数，创建空的List适配器
     */
    List() = default;

    /**
     * 指定初始容量的构造函数
     * @param initialCapacity 初始容量
     */
    explicit List(size_type initialCapacity) {
        data.reserve(initialCapacity);
    }

    /**
     * 初始化列表构造函数
     * @param initList 初始化列表
     */
    List(std::initializer_list<T> initList) : data(initList) {}

    /**
     * 拷贝构造函数
     * @param other 要拷贝的对象
     */
    List(const List& other) : data(other.data) {}

    /**
     * 移动构造函数
     * @param other 要移动的对象
     */
    List(List&& other) noexcept : data(std::move(other.data)) {}

    /**
     * 拷贝赋值运算符
     * @param other 要拷贝的对象
     * @return 当前对象的引用
     */
    List& operator=(const List& other) {
        if (this != &other) {
            data = other.data;
        }
        return *this;
    }

    /**
     * 移动赋值运算符
     * @param other 要移动的对象
     * @return 当前对象的引用
     */
    List& operator=(List&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
        }
        return *this;
    }

    /**
     * 析构函数
     */
    ~List() = default;

    // ========== Java List风格的基本信息方法 ==========

    /**
     * 获取List中元素的数量 (对应Java List.size())
     * @return 元素数量
     */
    size_type size() const noexcept {
        return data.size();
    }

    /**
     * 检查List是否为空 (对应Java List.isEmpty())
     * @return 如果为空返回true，否则返回false
     */
    bool isEmpty() const noexcept {
        return data.empty();
    }

    /**
     * 获取List的当前容量
     * @return 当前容量
     */
    size_type capacity() const noexcept {
        return data.capacity();
    }

    // ========== Java List风格的元素访问方法 ==========

    /**
     * 获取指定位置的元素 (对应Java List.get())
     * @param index 索引位置
     * @return 指定位置的元素引用
     * @throws std::out_of_range 如果索引超出范围
     */
    T& get(size_type index) {
        if (index >= size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        return data[index];
    }

    /**
     * 获取指定位置的元素（const版本）
     * @param index 索引位置
     * @return 指定位置的元素const引用
     * @throws std::out_of_range 如果索引超出范围
     */
    const T& get(size_type index) const {
        if (index >= size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        return data[index];
    }

    /**
     * 设置指定位置的元素值 (对应Java List.set())
     * @param index 索引位置
     * @param element 新的元素值
     * @return 原来的元素值
     * @throws std::out_of_range 如果索引超出范围
     */
    T set(size_type index, const T& element) {
        if (index >= size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        T oldValue = data[index];
        data[index] = element;
        return oldValue;
    }

    // ========== Java List风格的修改方法 ==========

    /**
     * 在List末尾添加元素 (对应Java List.add())
     * @param element 要添加的元素
     * @return 总是返回true（与Java List保持一致）
     */
    bool add(const T& element) {
        data.push_back(element);
        return true;
    }

    /**
     * 在List末尾添加元素（移动版本）
     * @param element 要添加的元素
     * @return 总是返回true
     */
    bool add(T&& element) {
        data.push_back(std::move(element));
        return true;
    }

    /**
     * 在指定位置插入元素 (对应Java List.add(index, element))
     * @param index 插入位置
     * @param element 要插入的元素
     * @throws std::out_of_range 如果索引超出范围
     */
    void add(size_type index, const T& element) {
        if (index > size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        data.insert(data.begin() + index, element);
    }

    /**
     * 在指定位置插入元素（移动版本）
     * @param index 插入位置
     * @param element 要插入的元素
     * @throws std::out_of_range 如果索引超出范围
     */
    void add(size_type index, T&& element) {
        if (index > size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        data.insert(data.begin() + index, std::move(element));
    }

    /**
     * 删除指定位置的元素 (对应Java List.remove(index))
     * @param index 要删除的位置
     * @return 被删除的元素
     * @throws std::out_of_range 如果索引超出范围
     */
    T remove(size_type index) {
        if (index >= size()) {
            throw std::out_of_range("Index " + std::to_string(index) +
                                  " out of bounds for size " + std::to_string(size()));
        }
        T removedElement = data[index];
        data.erase(data.begin() + index);
        return removedElement;
    }

    /**
     * 删除第一个匹配的元素 (对应Java List.remove(Object))
     * @param element 要删除的元素
     * @return 如果找到并删除了元素返回true，否则返回false
     */
    bool remove(const T& element) {
        auto it = std::find(data.begin(), data.end(), element);
        if (it != data.end()) {
            data.erase(it);
            return true;
        }
        return false;
    }

    /**
     * 清空List中的所有元素 (对应Java List.clear())
     */
    void clear() noexcept {
        data.clear();
    }

    // ========== Java List风格的查询方法 ==========

    /**
     * 检查List是否包含指定元素 (对应Java List.contains())
     * @param element 要查找的元素
     * @return 如果包含该元素返回true，否则返回false
     */
    bool contains(const T& element) const {
        return std::find(data.begin(), data.end(), element) != data.end();
    }

    /**
     * 查找指定元素第一次出现的位置 (对应Java List.indexOf())
     * @param element 要查找的元素
     * @return 元素的索引位置，如果未找到返回-1
     */
    int indexOf(const T& element) const {
        auto it = std::find(data.begin(), data.end(), element);
        if (it != data.end()) {
            return static_cast<int>(std::distance(data.begin(), it));
        }
        return -1;
    }

    /**
     * 查找指定元素最后一次出现的位置 (对应Java List.lastIndexOf())
     * @param element 要查找的元素
     * @return 元素的索引位置，如果未找到返回-1
     */
    int lastIndexOf(const T& element) const {
        auto it = std::find(data.rbegin(), data.rend(), element);
        if (it != data.rend()) {
            return static_cast<int>(data.size() - 1 - std::distance(data.rbegin(), it));
        }
        return -1;
    }

    // ========== 容量管理方法 ==========

    /**
     * 确保List的容量至少为指定值
     * @param minCapacity 最小容量
     */
    void ensureCapacity(size_type minCapacity) {
        if (capacity() < minCapacity) {
            data.reserve(minCapacity);
        }
    }

    /**
     * 将容量调整为当前大小，释放多余空间
     */
    void trimToSize() {
        data.shrink_to_fit();
    }

    // ========== 迭代器支持 ==========

    iterator begin() noexcept { return data.begin(); }
    const_iterator begin() const noexcept { return data.begin(); }
    const_iterator cbegin() const noexcept { return data.cbegin(); }

    iterator end() noexcept { return data.end(); }
    const_iterator end() const noexcept { return data.end(); }
    const_iterator cend() const noexcept { return data.cend(); }

    reverse_iterator rbegin() noexcept { return data.rbegin(); }
    const_reverse_iterator rbegin() const noexcept { return data.rbegin(); }
    const_reverse_iterator crbegin() const noexcept { return data.crbegin(); }

    reverse_iterator rend() noexcept { return data.rend(); }
    const_reverse_iterator rend() const noexcept { return data.rend(); }
    const_reverse_iterator crend() const noexcept { return data.crend(); }

    // ========== 运算符重载 ==========

    /**
     * 下标运算符，提供直接访问（无边界检查）
     * @param index 索引位置
     * @return 指定位置的元素引用
     */
    T& operator[](size_type index) {
        return data[index];
    }

    /**
     * 下标运算符，提供直接访问（const版本）
     * @param index 索引位置
     * @return 指定位置的元素const引用
     */
    const T& operator[](size_type index) const {
        return data[index];
    }

    /**
     * 相等性比较运算符
     * @param other 要比较的对象
     * @return 如果两个List内容相同返回true
     */
    bool operator==(const List& other) const {
        return data == other.data;
    }

    /**
     * 不等性比较运算符
     * @param other 要比较的对象
     * @return 如果两个List内容不同返回true
     */
    bool operator!=(const List& other) const {
        return data != other.data;
    }

    // ========== 辅助方法 ==========

    /**
     * 获取底层vector的引用（谨慎使用）
     * @return 底层vector的const引用
     */
    const std::vector<T>& getUnderlyingVector() const noexcept {
        return data;
    }

    /**
     * 转换为std::vector
     * @return 包含所有元素的vector副本
     */
    std::vector<T> toVector() const {
        return data;
    }

    /**
     * 获取子列表 (对应Java List.subList())
     * @param fromIndex 起始位置（包含）
     * @param toIndex 结束位置（不包含）
     * @return 包含子列表元素的新VectorListAdapter
     * @throws std::out_of_range 如果索引超出范围
     */
    List subList(size_type fromIndex, size_type toIndex) const {
        if (fromIndex > toIndex || toIndex > size()) {
            throw std::out_of_range("Invalid sublist range");
        }
        List result;
        result.data = std::vector<T>(data.begin() + fromIndex, data.begin() + toIndex);
        return result;
    }
};

#endif // VECTOR_LIST_ADAPTER_H